<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        function Promise(excutor){
            const shlt = this;
            shlt.status = 'peding' //记录状态
            shlt.data = null    //保存数据
            shlt.callbacks = [] //保存回调函数 then中的两个回调函数
            //excutor是一个函数类型，就是new Promise((resolve,rejevct)=>{})
            // 当我们一开始，就要调用这个函数，就会调用整个实参里的内容
            
            //我们改变Promise状态是根据调用的resolve() reject()这两个函数来改变的，而且我们是当普通函数来调用的
            //现在我们是要实现resolve() reject()这两个函数，当不是我来调用，而是用户来调用
            function resolve(value){
                if (shlt.status !== 'peding'){
                    return

                }
                //当我们调用了resolve函数时，就要改变promise的状态了
                shlt.status = 'resolved'
                //我们还要保存数据
                shlt.data = value
                // 如果有callbacks函数，立即异步执行回调函数onResolved
                if (shlt.callbacks.length > 0){
                    shlt.callbacks.forEach(element => {
                        //我们的this.callbacks中每一项是一个对象，对象中有两个函数，一个是:onRejected 一个是onResolved
                        //而且我们的回调函数还一定要是异步执行的
                        setTimeout(()=>{
                         element.onResolved(value)
                        })
                        
                    });

                }

            }
            function reject(reason) {
                if (shlt.status !== 'peding'){
                    return

                }
                shlt.status = 'rejected'
                shlt.data = reason
                if (shlt.callbacks.length > 0){
                    shlt.callbacks.forEach(item=>{
                        setTimeout(()=>{
                            item.onRejected(reason);
                        })
                    })
                }
            }

        
         
            try {
                excutor(resolve,reject)    
            } catch (error) {
                reject(error)
                
            }

        }
        Promise.prototype.then = function (onResolved,onRejected){
            //当状态还是peding时，当时我们已经给了回调函数来
            //我们应该把回调函数给保存起来，但是不要调用
            const _this = this
           return new Promise((resolve,reject)=>{
            if (this.status === 'peding') {
                    this.callbacks.push({
                    onResolved(){
                        try{
                        const result = onResolved(_this.data)
                        //剩余的第二种，和第三种情况我们要根据onResolved(this.data)的返回值来决定，所以我们在这里我们接受它的返回值
                        if (result instanceof Promise) {
                            //如何他的返回值是一个Promise就是这个种情况 那么result就是一个Promise
                            result.then(vlaue=>{
                                //如果result的是这样的Promise.reslove(12)那么，他的then中就会执行这个函数，而不执行下面的那个函数
                                resolve(value)
                                //我们这里改变了onResolved(this.data)返回一个新的Promise的状态是通过 调用新的Promise的resolve()的回调函数来实现
                            },reason=>{
                                //我们这里改变了onResolved(this.data)返回一个新的Promise的状态是通过 调用新的Promise的reject()的回调函数来实现
                                reject(reason)
                            })


                        }else {
                            //这里就是第2种情况，返回的是一个非Promise的数据
                            //那么我们return 一个新的Promise的状态就是resolve的
                            resolve(result);
                        }
                    }catch (error){
                        //1.这个是为了满足第一种情况,我们要捕获异常
                        reject(error)

                    }
                    },
                    onRejected(){
                        try{
                        const result = onRejected(_this.data)
                        //剩余的第二种，和第三种情况我们要根据onResolved(this.data)的返回值来决定，所以我们在这里我们接受它的返回值
                        if (result instanceof Promise) {
                            //如何他的返回值是一个Promise就是这个种情况 那么result就是一个Promise
                            result.then(vlaue=>{
                                //如果result的是这样的Promise.reslove(12)那么，他的then中就会执行这个函数，而不执行下面的那个函数
                                resolve(value)
                                //我们这里改变了onResolved(this.data)返回一个新的Promise的状态是通过 调用新的Promise的resolve()的回调函数来实现
                            },reason=>{
                                //我们这里改变了onResolved(this.data)返回一个新的Promise的状态是通过 调用新的Promise的reject()的回调函数来实现
                                reject(reason)
                            })


                        }else {
                            //这里就是第2种情况，返回的是一个非Promise的数据
                            //那么我们return 一个新的Promise的状态就是resolve的
                            resolve(result);
                        }
                    }catch (error){
                        //1.这个是为了满足第一种情况,我们要捕获异常
                        reject(error)

                    }

                    }

                
                })
            }else if (this.status === 'resolved') {
                //我们就要调用这个onResolved函数
                //但是我们的回调函数一定要是异步调用的
                //我们使用setTimeout()来实现异步
                setTimeout(()=>{
                    //我们的回调函数一定会返回一个新的Promise的实例，但是他的状态是会有变化的，是根据他的执行的then的回调函数的return的结果来决定的，有三种情况:
                    //1.当执行的onResolve抛出异常的时候，我们的return Promise的状态是失败的
                    //2.当执行的onResolve的返回值是一个非Promise的时候，我们新的Promise的状态是成功的
                    //3.当执行的onResolve的返回值是一个Promise的时候，我们新的Promise的状态是根据return 的Promise的状态来决定的
                    try{
                        const result = onResolved(this.data)
                        //剩余的第二种，和第三种情况我们要根据onResolved(this.data)的返回值来决定，所以我们在这里我们接受它的返回值
                        if (result instanceof Promise) {
                            //如何他的返回值是一个Promise就是这个种情况 那么result就是一个Promise
                            result.then(vlaue=>{
                                //如果result的是这样的Promise.reslove(12)那么，他的then中就会执行这个函数，而不执行下面的那个函数
                                resolve(value)
                                //我们这里改变了onResolved(this.data)返回一个新的Promise的状态是通过 调用新的Promise的resolve()的回调函数来实现
                            },reason=>{
                                //我们这里改变了onResolved(this.data)返回一个新的Promise的状态是通过 调用新的Promise的reject()的回调函数来实现
                                reject(reason)
                            })


                        }else {
                            //这里就是第2种情况，返回的是一个非Promise的数据
                            //那么我们return 一个新的Promise的状态就是resolve的
                            resolve(result);
                        }
                    }catch (error){
                        //1.这个是为了满足第一种情况,我们要捕获异常
                        reject(error)

                    }
                    
                })

            }else {
                //这里是状态是是rejected的时候
                //我们的回调函数一定会返回一个新的Promise的实例，但是他的状态是会有变化的，是根据他的执行的then的回调函数的return的结果来决定的，有三种情况:
                //1.当执行的onResolve抛出异常的时候，我们的return Promise的状态是失败的
                 //2.当执行的onResolve的返回值是一个非Promise的时候，我们新的Promise的状态是成功的
                //3.当执行的onResolve的返回值是一个Promise的时候，我们新的Promise的状态是根据return 的Promise的状态来决定的
                setTimeout(()=>{
                    try{
                        const result = onRejected(this.data)
                        //剩余的第二种，和第三种情况我们要根据onResolved(this.data)的返回值来决定，所以我们在这里我们接受它的返回值
                        if (result instanceof Promise) {
                            //如何他的返回值是一个Promise就是这个种情况 那么result就是一个Promise
                            result.then(vlaue=>{
                                //如果result的是这样的Promise.reslove(12)那么，他的then中就会执行这个函数，而不执行下面的那个函数
                                resolve(value)
                                //我们这里改变了onResolved(this.data)返回一个新的Promise的状态是通过 调用新的Promise的resolve()的回调函数来实现
                            },reason=>{
                                //我们这里改变了onResolved(this.data)返回一个新的Promise的状态是通过 调用新的Promise的reject()的回调函数来实现
                                reject(reason)
                            })


                        }else {
                            //这里就是第2种情况，返回的是一个非Promise的数据
                            //那么我们return 一个新的Promise的状态就是resolve的
                            resolve(result);
                        }
                    }catch (error){
                        //1.这个是为了满足第一种情况,我们要捕获异常
                        reject(error)

                    }


                })
                

            }
            
            //我们要调用onResolved，是当状态值为resolved是才会，调用onResolved的，我们只是调用，而是用户来定义这个函数
            
            
           })

        }
        Promise.prototype.catch = function(){

        }
        Promise.all = function (){

        }
        Promise.race = function (){

        }
        Promise.reject = function (){

        }
        Promise.resolve = function (){

        }
        const p = new Promise((resolve,reject)=>{
            // setTimeout(()=>{
                resolve(56)
            // },5000)
        })
        p.then(value=>{
            console.log('onResolve1:'+value)
            return 23
        },reason=>{
            console.log('onReject2:'+reason)
        }
        ).then(value=>{
            console.log("243",value)
            return '杨云党'
        },reson => {
            console.log(reson)
        }).then(value=>{
            console.log(value)
        })
        
    </script>
</body>
</html>